import java.io.Serializable;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Observable;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import javax.swing.JFrame;
/**
 * Classe controleur et application (système)
 * 
 * @author IUT, A. Culet
 * @version 1.0
 */

// public class Controleur extends Observable implements Serializable{
public class Controleur implements Serializable {
private JFrame frame;
	private static final long serialVersionUID = 1L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation Elle est
	 * également la classe "application" qui gère l'ensemble des objets de
	 * l'appli
	 */
	// ************************************************************************************************************
	// Attributs
	// ************************************************************************************************************

	// Attributs d'Association
	// Ensemble des ouvrages de la bibliothèque
	private HashMap<String, Ouvrage> _ouvrages;
	private HashMap<String, Index> _index;
	private HashMap<String, Periodique> _periodiques;
	private HashMap<String, Article> _articles;
	private HashMap<String, Parution> _parutions;


	// les différentes fenêtres pour chaque fonctionnalité
	private VueMenuBiblio _vueMenuBiblio = null;

	// une seule fenêtre est active à la fois; les autres sont à null.
	// permet de connaître l'état des fenêtres de l'interface
	private VueSaisieOuvrage _vueSaisieOuvrage = null;
	private VueSaisiePeriodique _vueSaisiePeriodique = null;
	private VueSaisieExemplaire _vueSaisieExemplaire = null;
	private VueConsultOuvrage _vueConsultOuvrage = null;
	private VueConsultParution _vueConsultParution = null;
	private VueConsultPeriodique _vueConsultPeriodique = null;
	private VueRecherche _vueRecherche = null;
	private VueSaisieParution _vueSaisieparution = null;
	private VueSaisieParutionArticle _VueSaisieParutionArticle = null;

	// ************************************************************************************************************
	// Constructeur
	// ************************************************************************************************************

	public Controleur() {
		this.setOuvrages(new HashMap<String, Ouvrage>());
		this.setIndex(new HashMap<String, Index>());
		this.setPeriodique(new HashMap<String, Periodique>());		
		_articles = new HashMap<String, Article>();
		_parutions =new HashMap<String, Parution>();
		lectureLignesFichier();

		

	} // Fin Controleur

	// ************************************************************************************************************
	// Méthodes privées
	// ************************************************************************************************************

	// ------------------------------------------------------------------------------------------------------------
	// Affecteurs

	public void lectureLignesFichier() {

		try {
			BufferedReader in = new BufferedReader(new FileReader(
					"/users/info/etu-s3/aklis/Projet/biblioGraphiqueV2/src/ListeAutorite.txt"));
			String ligne;
			while ((ligne = in.readLine()) != null) {
				MotsClee i = new MotsClee(ligne);
				_index.put(ligne, i);
			}
			in.close();
		}

		catch (IOException e) {
			System.out.println("$$$$$ PB de Lecture dans le fichier XXXXX ");
			System.out.println();
		}

	} // lectureLignesFichier;

	/**
	 * Ajoute un ouvrage à l'ensemble des ouvrages de la bibliothèque.
	 * 
	 * @param ouvrage
	 *            Ouvrage à ajouter
	 * @param isbn
	 *            code ISBN de cet ouvrage
	 */
	private void setOuvrage(Ouvrage ouvrage, String isbn) {
		this.getOuvrages().put(isbn, ouvrage);
	} // Fin setOuvrage

	private void setArticles(Article article, String titre) {
			this.getArticles().put(titre, article);
	}
	
	private void setPeriodique(Periodique periodique, String issn) {
		this.getPeriodiques().put(issn, periodique);
	}
	
	private void setIndex(Index index, String auteur) {
			this.getIndex().put(auteur, index);
	}
	///////////////////////////////////////////
	//Ajoute un périodique dans _periodiques.//
	
	private void setPeriodique(Periodique periodique) {
		this.get_periodiques().put(periodique.get_issn(), periodique);
	}
	///////////////////////////////////////////
	//Ajoute un périodique dans _articles.//
	private void setArticle(Article article) {
		this.get_articles().put(article.get_titre(), article);
	}
	/**
	 * @param ouvrages
	 *            hashtable d'ouvrages à affecter
	 */
	private void setOuvrages(HashMap<String, Ouvrage> ouvrages) {
		_ouvrages = ouvrages;
	}// Fin setOuvrages

	private void setPeriodique(HashMap<String, Periodique> periodique) {
		_periodiques = periodique;
	}
	
	private void setIndex(HashMap<String, Index> index) {
		_index = index;
	}

	/**
	 * @param vue
	 *            la vue à affecter
	 */
	private void setVueMenuBiblio(VueMenuBiblio vue) {
		_vueMenuBiblio = vue;
	}// Fin setVueVueMenuBiblio

	private void setVueSaisieOuvrage(VueSaisieOuvrage vue) {
		_vueSaisieOuvrage = vue;
	}// Fin setVueVueSaisieOuvrage
	
	private void set_VueSaisiePeriodique(VueSaisiePeriodique vue) {
		this._vueSaisiePeriodique = vue;
	}

	private void setVueSaisieExemplaire(VueSaisieExemplaire vue) {
		_vueSaisieExemplaire = vue;
	}// Fin setVueVueSaisieExemplaire

	private void setVueConsultOuvrage(VueConsultOuvrage vue) {
		_vueConsultOuvrage = vue;
	}// Fin setVueVueConsultOuvrage
	
	private void setVueConsultParution(VueConsultParution vue) {
		_vueConsultParution = vue;
	}
	
	private void setVueConsultPeriodique(VueConsultPeriodique vue) {
		_vueConsultPeriodique = vue;
	}
	private void setVueRecherche(VueRecherche vue) {
		_vueRecherche = vue;
	}// Fin setVueRecherche
	private void set_periodiques(HashMap<String, Periodique> _periodiques) {
		this._periodiques = _periodiques;
	}
	private void set_vueSaisieparution(VueSaisieParution vue) {
		this._vueSaisieparution = vue;
	}
	public void setVueSaisieParutionArticle(VueSaisieParutionArticle vue) {
		_VueSaisieParutionArticle = vue;
	}// Fin setVueVueSaisieExemplaire

	// ------------------------------------------------------------------------------------------------------------
	// Accesseurs

	/**
	 * @return ensemble des ouvrages de la bibliothèque
	 */
	private HashMap<String, Ouvrage> getOuvrages() {
		return _ouvrages;
	}// Fin getOuvrages

	private HashMap<String, Article> getArticle() {
		return _articles;
	}
	
	private HashMap<String, Periodique> getPeriodiques() {
		return _periodiques;
	}// Fin getOuvrages
	
	private HashMap<String, Article> getArticles() {
			return _articles;
	}
	
	public HashMap<String, Index> getIndex() {
		return _index;
	}
	
	public HashSet<Ouvrage> getIndexRech(String rech) {

		Index objet=_index.get(rech);
	if ( ! (objet == null))	
	{
		return objet.getOuvrages();
	}
	else
		return null;	
	
}
	public HashSet<Article> getIndexRechParu(String rech) {

		Index objet=_index.get(rech);
	if ( ! (objet == null))	
	{
		return objet.getArticles();
	}
	else
		return null;	
	
}

	public HashSet<MotsClee> getMotsClee() {
		Collection<Index> index = _index.values();
		HashSet<MotsClee> mots = new HashSet<MotsClee>();
		for (Index i : index) {
			if (i.getType() == "MotsClee") {
				mots.add((MotsClee) i);
			}
		}
		return mots;
	}
	/////////////////////////////////////
	/*Renvoie la liste des périodiques */
	
	public HashSet<Periodique> getPeriodiqueSet() {
		Collection<Periodique> perio = _periodiques.values();
		HashSet<Periodique> perios = new HashSet<Periodique>();
		for (Periodique i : perio) {
			perios.add((Periodique) i);
		}
		return perios;
	}
	
	
	/////////////////////////////////////
	/*Renvoie la liste des articles */
	
	public HashSet<Article> getArticleSeq() {
		Collection<Article> article = _articles.values();
		HashSet<Article> articles = new HashSet<Article>();
		for (Article i : article) {
			articles.add((Article) i);
		}
		return articles;
	}	
	
	/**
	 * Accès à un ouvrage par son numéro ISBN
	 * 
	 * @param isbn
	 *            le code ISBN de l'ouvrage cherché
	 * @return l'ouvrage qui a l'ISBN indiqué
	 */
	private Ouvrage getOuvrage(String isbn) {
		return this.getOuvrages().get(isbn);
	} // Fin getOuvrage

	
	public Periodique getPeriodique(String issn) {
		return this.getPeriodiques().get(issn);
	} 
	
	public Parution getParution(String idParution){
		return this.getParutions().get(idParution);
	}
	/**
	 * @return la vue
	 */
	private VueMenuBiblio getVueMenuBiblio() {
		return _vueMenuBiblio;
	}// Fin getVueVueMenuBiblio

	private VueSaisieOuvrage getVueSaisieOuvrage() {
		return _vueSaisieOuvrage;
	}// Fin getVueVueSaisieOuvrage

	private VueSaisieExemplaire getVueSaisieExemplaire() {
		return _vueSaisieExemplaire;
	}// Fin getVueVueSaisieExemplaire

	private VueConsultOuvrage getVueConsultOuvrage() {
		return _vueConsultOuvrage;
	}// Fin getVueVueConsultOuvrage
	
	private VueConsultParution getVueConsultParution() {
		return _vueConsultParution;
	}
	private VueConsultPeriodique getVueConsultPeriodique() {
		return _vueConsultPeriodique;
	}
	
	private VueRecherche getVueRecherche() {
		return _vueRecherche;
	}// Fin getVueVueConsultOuvrage
	
	private VueSaisieParutionArticle getVueSaisieParutionArticle() {
		return _VueSaisieParutionArticle;
	}// Fin getVueSaisieParutionArticle
	
	public Boolean rechercherMot(String mot) {
		if (!(_index.isEmpty())) {
			Message dialog = new Message("Périodique déjà présent");
			dialog.setVisible(true);
			return _index.containsValue(mot);
		} else
			return false;

	}
	public HashMap<String, Periodique> get_periodiques() {
		return _periodiques;
	}
	public VueSaisieParution get_vueSaisieparution() {
		return _vueSaisieparution;
	}
	
	public HashMap<String, Article> get_articles() {
		return _articles;
	}
	
	public HashMap<String, Parution> getParutions() {
		return _parutions;
	}
	public VueSaisiePeriodique get_vueSaisiePeriodique() {
		return _vueSaisiePeriodique;
	}
	
	

	// ************************************************************************************************************
	// Méthodes publiques de création et affichage des fenêtres de
	// l'application et fermeture
	// ************************************************************************************************************
	/**
	 * Création et affichage de la fenêtre principale de l'application. Elle
	 * reste affichée
	 */

	public void menuBiblio() {
		try {
			this.setVueMenuBiblio(new VueMenuBiblio(this));
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * Création et affichage de la fenêtre de consultation d'un ouvrage
	 */

	public void consulterOuvrage() {
		try {
			this.setVueConsultOuvrage(new VueConsultOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueConsultOuvrage
			this.getVueConsultOuvrage().setEtat(Vue.initiale);
			this.getVueConsultOuvrage().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void consulterPeriodique() {
		try {
			this.setVueConsultPeriodique(new VueConsultPeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueConsultOuvrage
			this.getVueConsultPeriodique().setEtat(Vue.initiale);
			this.getVueConsultPeriodique().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void consulterOuvrage(String isbn) {
		try {
			this.setVueConsultOuvrage(new VueConsultOuvrage(this,isbn));
			// le Menu est caché
			
			this.getVueConsultOuvrage().setEtat(Vue.inter1);
			this.getVueConsultOuvrage().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void ConsulterParution(Object selectedValue) {
		Parution par = _parutions.get(selectedValue.toString());
		try {
			this.setVueConsultParution(new VueConsultParution(this,par));
			// le Menu est caché
			this.getVueConsultPeriodique().setVisible(false);
			this.getVueConsultParution().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public void recherche(String rech) {

		HashSet<Ouvrage> ouv = getIndexRech(rech);
		HashSet<Article> paru = getIndexRechParu(rech);
		if(ouv == null)
		{
			Message dialog = new Message("Aucun resultat.");
			dialog.setVisible(true);
		}
		else
		{
		try {
			this.setVueRecherche(new VueRecherche(this, ouv, paru));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueConsultOuvrage
			this.getVueRecherche().setEtat(Vue.initiale);
			this.getVueRecherche().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
		}
	}

	/**
	 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
	 */
	public void saisirExemplaire() {
		try {
			this.setVueSaisieExemplaire(new VueSaisieExemplaire(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieExemplaire
			this.getVueSaisieExemplaire().setEtat(Vue.initiale);
			this.getVueSaisieExemplaire().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * Création et affichage de la fenêtre de saisie d'un ouvrage
	 */
	public void saisirOuvrage() {
		try {
			this.setVueSaisieOuvrage(new VueSaisieOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisieOuvrage().setEtat(Vue.initiale);
			this.getVueSaisieOuvrage().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Création et affichage de la fenêtre de saisie d'une nouvelle parution
	 */
	public void saisieParution() {
		try {
			this.set_vueSaisieparution(new VueSaisieParution(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false);
			// la vue courante est VueSaisieOuvrage
			//this.get_vueSaisieparution().setEtat(Vue.initiale);
			//this.get_vueSaisieparution().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public void AjouterArticle(String idParution){
		try{
			Parution par = this.getParution(idParution);
			this.setVueSaisieParutionArticle(new VueSaisieParutionArticle(this,par));
			// la vue courante est VueSaisieParutionArticle
			//this.getVueSaisieParutionArticle().setEtat(Vue.initiale);
			//this.getVueSaisieParutionArticle().setVisible(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public void saisieParution(String issn, String NomPeriodique) {
		try {
		
			this.set_vueSaisieparution(new VueSaisieParution(this, issn, NomPeriodique));
			//this.get_vueSaisieparution().setEtat(Vue.initiale);
			//this.get_vueSaisieparution().setVisible(true);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	public void saisiePeriodique() {
		try {
			this.set_VueSaisiePeriodique(new VueSaisiePeriodique(this));
			//this.get_vueSaisiePeriodique().setEtat(Vue.initiale);
			//this.get_vueSaisiePeriodique().setVisible(true);
			
			
			this.getVueMenuBiblio().getFrame().setVisible(false);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * fermeture de la fenêtre vue lors de la fermeture de la fenêtre
	 * principale de l'application sauvegarde des objets sérialisés
	 */
	public void fermerVue(Vue vue) {
		if (vue instanceof VueMenuBiblio) {
			// Quitte l'aplication. Sauvegarde les objets du modèle
			this.sauve();
			System.exit(0);
		}
		vue.dispose();
		// le Menu est rendu de nouveau visible
		this.getVueMenuBiblio().getFrame().setVisible(true);
		this.resetVues();
	}

	// Restaure l'état de l'interface avec seule la fenêtre du Menu principal
	// active
	private void resetVues() {
		this.setVueSaisieOuvrage(null);
		this.setVueConsultOuvrage(null);
		this.set_VueSaisiePeriodique(null);
		this.setVueSaisieExemplaire(null);
		this.setVueRecherche(null);
		this.set_vueSaisieparution(null);
		
	}

	// ************************************************************************************************************
	// Opérations liées à la sérialisation des objets de l'application
	// ************************************************************************************************************
	/**
	 * restauration des objets de l'application
	 */
	public Controleur restaure() {
		try {
			FileInputStream fichier = new FileInputStream("Fsauv.ser");
			ObjectInputStream in = new ObjectInputStream(fichier);
			return ((Controleur) in.readObject());
		} catch (Exception e) {
			Message dialog = new Message(
					"Pbs de Restauration ou fichier non encore créé");
			dialog.setVisible(true);
			return this;
		}
	}

	/**
	 * sauvegarde des objets de l'application
	 */
	private void sauve() {
		try {
			FileOutputStream f = new FileOutputStream("Fsauv.ser");
			ObjectOutputStream out = new ObjectOutputStream(f);
			out.writeObject(this);
		} catch (Exception e) {
			Message dialog = new Message("Pb de Sauvegarde dans le fichier");
			dialog.setVisible(true);
		}
	}

	// ************************************************************************************************************
	// Opérations liées à l'application en réponse à une action de
	// l'utilisateur dans une vue
	// ************************************************************************************************************

	/**
	 * Accès à un ouvrage par son numéro ISBN Invoqué dans VueConsultOuvrage
	 * et VueSaisieExemplaire
	 * 
	 * @param isbn
	 *            le code ISBN de l'ouvrage cherché
	 * @return l'ouvrage qui a l'ISBN indiqué ou null affiche un message
	 *         d'erreur si l'ouvrage n'est pas trouvé
	 */
	public Ouvrage rechOuvrage(String isbn) {
		Ouvrage ouv = this.getOuvrage(isbn);
		if (ouv == null) {
			Message dialog = new Message("Ouvrage inconnu");
			dialog.setVisible(true);
		} else {
			// la vue courante est VueSaisieExemplaire
			if (this.getVueSaisieExemplaire() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage
				ouv.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
				this.getVueSaisieExemplaire().setEtat(Vue.inter1);
				this.getVueSaisieExemplaire().alimente(ouv);
			}
			// la vue courante est VueConsultOuvrage
			if (this.getVueConsultOuvrage() != null) {
				// le contrôleur modifie l'état de la vue
				this.getVueConsultOuvrage().setEtat(Vue.finale);
				this.getVueConsultOuvrage().alimente(ouv);
			}
		}
		return ouv;
	} // Fin rechOuvrage
	
	public Periodique rechPeriodique(String issn) {
		Periodique p = this.getPeriodique(issn);
		if (p == null) {
			Message dialog = new Message("Periodique inconnu");
			dialog.setVisible(true);
		} else {
				this.getVueConsultPeriodique().setEtat(Vue.finale);
				this.getVueConsultPeriodique().alimente(p);
			}
		
		return p;
	} // Fin rechOuvrage
	////////////////////////////////////////////////////////////////////////////////////
	//ajoute une parution dans les diférrents Hashmap (controleur,periodique,parution)//
	public boolean ajouterParution(Periodique per,String idParution,String titre, String date){
		Parution par= new Parution(idParution,titre,date);
		boolean dejaEnr = false;
		if(per.get_parutions().containsKey(idParution))
				{
				Message dialog = new Message(
					"Parution déjà enregistrée.");
				dialog.setVisible(true);
				dejaEnr = true;
				}
		else{
			_parutions.put(par.get_IdParution(), par);
			par.lierperiodique(per);
			per.lierparution(par);
		}
		return(dejaEnr);
	}

	/**
	 * Création d'un exemplaire d'ouvrage Invoqué dans VueSaisieExemplaire
	 * 
	 * @param ouv
	 *            l'ouvrage dateRecep la date de réception de l'exemplaire
	 *            affiche un message de confirmation après l'enregistrement ou
	 *            un message d'erreur
	 */
	public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
		// vérification de la présence de la date et de son format
		if (dateReception.length() == 0) {
			Message dialog = new Message(
					"La date de réception est obligatoire");
			dialog.setVisible(true);
		} else {
			GregorianCalendar date = ESDate.lireDate(dateReception);
			if (date == null) {
				Message dialog = new Message(
						"Le format de la date est incorrect");
				dialog.setVisible(true);
			} else {
				int statutEx;
				if (statut == "empruntable") {
					statutEx = Exemplaire.EMPRUNTABLE;
				} else {
					statutEx = Exemplaire.EN_CONSULTATION;
				}
				// demande d'ajout de l'exemplaire
				Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
				// l'opération s'est bien passée
				if (exemplaire != null) {
					// le contrôleur modifie l'état de la vue
					this.getVueSaisieExemplaire().setEtat(Vue.finale);
					// affichage d'un message de confirmation
					Message dialog = new Message("Exemplaire enregistré");
					dialog.setVisible(true);
				} else {
					Message dialog = new Message(
							"Date de Reception incorrecte / à la date d'Edition.");
					dialog.setVisible(true);
				}
			}
		}
	} // Fin nouvExemplaire

	/**
	 * Création d'un d'ouvrage Invoqué dans VueSaisieOuvrage
	 * 
	 * @param dateEdition
	 *            la date d'édition de l'ouvrage affiche un message de
	 *            confirmation après l'enregistrement ou un message d'erreur
	 */
	public void nouvOuvrage(String isbn, String titre, HashSet<String> auteurs,
			String editeur, String dateEdition,Object[] mots) {
		// vérification de la présence des infos obligatoires et du format de
		// la date

		if ((isbn.length() == 0) || (titre.length() == 0)
				|| (auteurs.isEmpty()) || (editeur.length() == 0)
				|| (dateEdition.length() == 0 || (mots.length ==0))) {
			Message dialog = new Message("Tous les champs sont obligatoires");
			dialog.setVisible(true);
		} else {
			GregorianCalendar date = ESDate.lireDate(dateEdition);
			if (date == null) {
				Message dialog = new Message(
						"Le format de la date est incorrect");
				dialog.setVisible(true);
			} else if (this.getOuvrage(isbn) == null) {
				// Instanciation de l'ouvrage
				Ouvrage ouvrage = new Ouvrage(isbn, titre, editeur, date);
				// Ajout de l'ouvrage dans l'ensemble des ouvrages de la
				// bibliothèque
				this.setOuvrage(ouvrage, isbn);
				EnregistrerAuteur(auteurs,ouvrage);
				EnregistrerMotsClee(mots,ouvrage);
				Message dialog = new Message("Ouvrage enregistré");
				dialog.setVisible(true);
				this.fermerVue(this.getVueSaisieOuvrage());
			} else {
				Message dialog = new Message("Ouvrage déjà présent");
				dialog.setVisible(true);
			}
		}
	}
	
	
	public void nouvPeriodique (String issn, String NomPeriodique) {
		// vérification de la présence des infos obligatoires et du format de
		// la date

		if (this.getPeriodique(issn) == null) {
				Periodique periodique = new Periodique(issn, NomPeriodique);
				this.setPeriodique(periodique, issn);
				Message dialog2 = new Message("Périodique enregistré");
				dialog2.setVisible(true);
				
		} else {
				Message dialog = new Message("Périodique déjà présent");
				dialog.setVisible(true);
		}
		}
	
	

	

	public void EnregistrerAuteur( HashSet<String> auteurs,Ouvrage ouvrage)
	{
		Auteur a;
		for (String auteur : auteurs) {
			if (_index.get(auteur)== null) {
				a = new Auteur(auteur);
				this.setIndex(a, auteur);
			} else {

				a = (Auteur) _index.get(auteur);
			}
			a.lierOuvrage(ouvrage);
			ouvrage.lierAuteur(a);
		}
	}

	 public void EnregistrerMotsClee(Object[] mots,Ouvrage ouv)
	{
	for(int i=0; i<mots.length;i++)
	{
		MotsClee m = (MotsClee)_index.get(mots[i]);
		ouv.lierMot(m);
		m.lierOuvrage(ouv);
	}
	}

	public void EnregistrerArticle(Parution par,String titre,String nbPages,HashSet<String> auteurs,HashSet<String> motsClees){
		Auteur a;
		try
		{
		Article art = new Article(titre,Integer.parseInt(nbPages),par);
		
		 this.setArticles(art,titre);
		 for (String auteur : auteurs) {
			 if ((_index.get(auteur)==null)) {
				 a = new Auteur(auteur);
				 this.setIndex(a, auteur);
			 } else {
				 a = (Auteur) _index.get(auteur);
			 }
		 	 	a.lierArticle(art);
		 	 	art.lierAuteur(a);
		 }
		 for(String mot : motsClees)
		 {
			 MotsClee m = (MotsClee) _index.get(mot);
			 art.lierMot(m);
			 m.lierArticle(art);
		 }
		 	par.lierArticle(art);
		 
	}
	catch(NumberFormatException e)
	{
		Message dialog = new Message("Vous devez rentrez un entier.");
		dialog.setVisible(true);
	}
	}
} // Fin nouvOuvrage

